import request from './index';
import axios from 'axios';

/**
 * 发送聊天消息
 * @param {Object} data 聊天数据
 * @param {Function} onProgress 进度回调函数，用于处理流式响应
 * @returns {Promise} 请求Promise
 */
export function sendChatMessage(data, onProgress) {
  const formData = new FormData();
  
  // 确保prompt不为空，如果为空则使用默认值
  const prompt = data.prompt || (data.files && data.files.length > 0 ? "[图片消息]" : "空消息");
  formData.append('prompt', prompt);
  
  // chatId是可选参数
  if (data.chatId) {
  formData.append('chatId', data.chatId);
  }
  
  // 处理文件上传
  let hasValidFile = false;
  
  if (data.files && data.files.length > 0) {
    console.log('准备上传文件数量:', data.files.length);
    data.files.forEach((file, index) => {
      // 检查文件对象是否有效
      if (file instanceof File) {
        formData.append('files', file);
        hasValidFile = true;
        console.log(`添加文件${index+1}:`, file.name);
      } else if (file && file.raw instanceof File) {
        formData.append('files', file.raw);
        hasValidFile = true;
        console.log(`添加文件${index+1}:`, file.raw.name);
      } else {
        console.error('无效的文件对象:', file);
      }
    });
  }
  
  // 如果没有有效文件，添加一个空的空白文件
  if (!hasValidFile) {
    const emptyBlob = new Blob([''], { type: 'text/plain' });
    formData.append('files', emptyBlob, 'empty.txt');
    console.log('添加空白文件以满足API要求');
  }
  
  const token = localStorage.getItem('token');
  // 使用原生fetch来处理流式响应
  return new Promise((resolve, reject) => {
    console.log('发送请求到:', '/ai/chat');
    console.log('使用授权Token:', token ? '已设置' : '未设置');
    
    // 构建API URL - 使用完整URL而不是相对路径
    const apiUrl = import.meta.env.DEV 
      ? '/ai/chat' // 开发环境使用相对路径，由Vite代理处理
      : `${window.location.origin}/ai/chat`; // 生产环境使用完整URL
    
    fetch(apiUrl, {
      method: 'POST',
      body: formData,
      credentials: 'include',
      headers: {
        'Authorization': `Bearer ${token}`
      }
    })
    .then(response => {
      if (!response.ok) {
        console.error('API响应错误:', response.status, response.statusText);
        throw new Error(`网络响应异常: ${response.status} ${response.statusText}`);
      }
      
      if (!response.body) {
        throw new Error('响应中没有数据流');
      }
      
      const reader = response.body.getReader();
      let receivedText = '';
      
      function readStream() {
        return reader.read().then(({ done, value }) => {
          if (done) {
            console.log('流式响应完成');
            resolve(receivedText);
            return;
          }
          
          // 将接收到的数据块转换为文本
          const chunk = new TextDecoder().decode(value, { stream: true });
          receivedText += chunk;
          
          // 调用进度回调
          if (onProgress) {
            onProgress(chunk);
          }
          
          // 继续读取下一个数据块
          return readStream();
        });
      }
      
      readStream().catch(error => {
        console.error('读取流失败:', error);
        reject(error);
      });
    })
    .catch(error => {
      console.error('请求失败:', error);
      reject(error);
    });
  });
}

/**
 * 获取聊天历史ID列表
 * @returns {Promise} 请求Promise
 */
export function getChatHistoryIds() {
  return new Promise((resolve) => {
    // 尝试从后端获取历史记录
    request({
      url: '/ai/history/chat',
      method: 'get'
    })
    .then(data => {
      resolve(data);
    })
    .catch(error => {
      console.error('获取聊天历史失败，使用本地存储:', error);
      // 如果后端请求失败，尝试从本地存储获取
      try {
        const chatIds = localStorage.getItem('chatIds');
        if (chatIds) {
          resolve(JSON.parse(chatIds));
        } else {
          resolve([]);
        }
      } catch (e) {
        console.error('从本地存储获取聊天历史失败:', e);
        resolve([]);
      }
    });
  });
}

/**
 * 保存聊天ID列表到本地存储
 * @param {Array} chatIds 聊天ID列表
 */
export function saveChatIds(chatIds) {
  try {
    localStorage.setItem('chatIds', JSON.stringify(chatIds));
  } catch (error) {
    console.error('保存聊天ID列表失败:', error);
  }
}

/**
 * 获取特定会话的消息历史
 * @param {String} chatId 会话ID
 * @returns {Promise} 请求Promise
 */
export function getChatMessages(chatId) {
  return new Promise((resolve) => {
    // 尝试从后端获取消息历史
    request({
      url: `/ai/history/chat/${chatId}`,
      method: 'get'
    })
    .then(data => {
      // 尝试将消息历史保存到本地存储
      try {
        localStorage.setItem(`messages_${chatId}`, JSON.stringify(data));
      } catch (e) {
        console.warn('保存消息历史到本地存储失败:', e);
      }
      resolve(data);
    })
    .catch(error => {
      console.error('获取消息历史失败，尝试从本地存储获取:', error);
      // 如果后端请求失败，尝试从本地存储获取
      try {
        const messages = localStorage.getItem(`messages_${chatId}`);
        if (messages) {
          resolve(JSON.parse(messages));
        } else {
          resolve([]);
        }
      } catch (e) {
        console.error('从本地存储获取消息历史失败:', e);
        resolve([]);
      }
    });
  });
}

/**
 * 删除聊天历史
 * @param {String} chatId 会话ID
 * @returns {Promise} 请求Promise
 */
export function deleteChatHistory(chatId) {
  return new Promise((resolve, reject) => {
    // 尝试从后端删除聊天历史
    request({
      url: `/ai/history/${chatId}`,
      method: 'delete'
    })
    .then((result) => {
      console.log('删除聊天历史成功:', result);
      // 从本地存储中删除
      try {
        localStorage.removeItem(`messages_${chatId}`);
      } catch (e) {
        console.warn('从本地存储删除消息历史失败:', e);
      }
      resolve(result);
    })
    .catch(error => {
      console.error('删除聊天历史失败:', error);
      // 即使后端删除失败，也从本地存储中删除
      try {
        localStorage.removeItem(`messages_${chatId}`);
      } catch (e) {
        console.warn('从本地存储删除消息历史失败:', e);
      }
      reject(error);
    });
  });
}
